import common from "../../../utils/common.js";
const { clockSvgSrc, trashCanSvgSrc, downWardSvgSrc, upWardSvgSrc, hotSvgSrc, iconSvgArr } = require('../../../utils/iconSvg')

const app = getApp()
const ip = app.globalData.ipStr
const token = wx.getStorageSync("token");
// 滑动块初始租金值 
const initMinRent = 800;
const initMaxRent = 3000;
const defaultColor = 'rgba(153,153,153, 1)';
const activeColor = 'rgba(255, 127, 80)';
Page({

    /**
     * 页面的初始数据
     */
    data: {
        windowHeight: app.globalData.windowHeight,

        // 公共变量，控制显示pre或select2,false时显示pre
        showPageFlag: false,
        // 公用输入的关键字
        searchKeyStr: '',
        complex: '',
        // 存放在筛选页选中的标签文本的字符串
        selectOptionsStr: '筛选',

        // 原预查询页面变量------------------------------------------------------------
        // 用于控制历史搜索key的展示 
        showHistorySerachKeyFlag: false,
        // 用于控制热点搜索key的展示 
        showHotSerachKeyFlag: false,
        // 用于控制是否显示 社区名匹配view的展示 
        showMatchComplexFlag: false,
        // 是否展示更多的 最近搜索关键词
        showMoreHistoryFlag: false,

        // 图标
        clockSvgSrc: clockSvgSrc('#A6A6A6'),
        trashCanSvgSrc: trashCanSvgSrc('#A6A6A6'),
        downWardSvgSrc: downWardSvgSrc('#A6A6A6'),
        upWardSvgSrc: upWardSvgSrc('#A6A6A6'),
        hotSvgSrc: hotSvgSrc('#A6A6A6'),
        defaultColor: defaultColor,
        activeColor: activeColor,

        searchKeyHistoryArr: [],
        omitSearchKeyHistoryArr: [],
        // 根据关键字匹配的社区名
        searchKeyMatchArr: [],


        // 原筛选页面变量------------------------------------------------------------
        // 搜索条件模块数组
        // 搜索条件模块数组
        selectModuleTextArr: ['区域', '户型', '租金', '筛选', ''],
        selectModuleArr: [{ type: 2, text: '区域', viewId: 'district' },
        { type: 4, text: '户型', viewId: 'layout', },
        { type: 6, text: '租金', viewId: 'rent', },
        { type: 10, text: '筛选', viewId: 'condition', },
        { type: 999, text: '', viewId: 'sort', },
        ],
        selectModuleTextWidth: app.globalData.windowWidth * 0.94 / 5,
        iconSvgSrcArr: iconSvgArr(-1, defaultColor, activeColor),
        fastSearchArr: [{ check: false, text: '有电梯', value: 4 }, { check: false, text: '可做饭', value: 6 }, { check: false, text: '无中介费', value: 10 }, { check: false, text: '全部', value: '-1' }],
        selectModuleViewHeight: '80',

        // 是否展示区域2、户型4、价格6、筛选10 view
        showSelectKindViewFlag: -1,
        // 选择模块距顶的高度，用于计算遮罩层和scroll层的高度
        topViewLowerBoundary: 0,

        // 区域数据
        districtData: {
            type: 2,
            title: '区域',
            optionArr: [
                { check: false, text: '西工区', value: '西工区' },
                { check: false, text: '老城区', value: '老城区' },
                { check: false, text: '涧西区', value: '涧西区' },
                { check: false, text: '瀍河回族区', value: '瀍河回族区' },
                { check: false, text: '洛龙区', value: '洛龙区' }
            ]
        },
        // 选中的区域数值
        districtSelectedValArr: [],
        // 区域view 下边界距离 
        districtViewLowerBoundary: 0,

        // 户型数据
        layoutData: {
            type: 4,
            title: '户型',
            optionArr: [
                { check: false, text: '一室', value: 1 },
                { check: false, text: '二室', value: 2 },
                { check: false, text: '三室', value: 3 },
                { check: false, text: '四室', value: 4 },
                { check: false, text: '五室+', value: 5 },
            ]
        },
        // 选中的户型数值
        layoutSelectedVal: -1,
        // 户型view 下边界距离 
        layoutViewLowerBoundary: 0,

        // 租金选项数据
        rentData: {
            type: 6,
            title: '租金',
            optionArr: [
                { check: false, text: '<800', value: 1 },
                { check: false, text: '800~1500', value: 2 },
                { check: false, text: '1500~2000', value: 3 },
                { check: false, text: '2000~2300', value: 4 },
                { check: false, text: '2300~2600', value: 5 },
                { check: false, text: '>2600', value: 6 }
            ]
        },
        // 租金view 下边界距离 
        rentViewLowerBoundary: 0,
        // 存放选中的某个租金选项的vaLue
        // rentSelectedVal: 0,
        movableAreaWidth: app.globalData.windowWidth * 0.94,//px
        movableViewWidthRPX: 60,//rpx
        maxShowViewWidth: 0,//width px
        maxRent: initMaxRent,
        minRent: initMinRent,
        // 这两个值是两个滑块的x值，只有在重置时恢复为0，否则不要乱动，因为控件会出现抖动
        _x1: 0,
        _x2: 0,
        // 这两个值分别对应两个滑块的x值，参与计算然后给show-view的width使用
        x1: 0,
        x2: 0,
        // 存放滑块移动过程中，经过计算后的两个租金值，确定时需要传给后端
        rent1: 0,
        rent2: 0,
        // 传给后端的值 
        rentVal1: 0,
        rentVal2: 0,

        // 出租方式数据
        rentTypeData: {
            type: 3,
            title: '承租方式',
            optionArr: [
                // { check: false, text: '全部', value: -1 },
                { check: false, text: '整租', value: 0 },
                { check: false, text: '合租', value: 1 },
            ]
        },
        // 存放选中的某个出租方式选项的vaLue
        rentTypeSelectedVal: -1,
        // 其它选项，数据与 “亮点”数据一样
        otherConditionData: {
            type: 7,
            title: '其它',
            optionArr: [
                { check: false, text: '精装修', value: 0 },
                { check: false, text: '智能家居', value: 1 },
                { check: false, text: '房东直租', value: 2 },
                { check: false, text: '民用水电', value: 3 },
                { check: false, text: '有电梯', value: 4 },
                { check: false, text: '双气', value: 5 },
                { check: false, text: '可做饭', value: 6 },
                { check: false, text: '可短租', value: 7 },
                { check: false, text: '可养宠物', value: 8 },
                { check: false, text: '带车位', value: 9 },
                { check: false, text: '无中介费', value: 10 },
            ]
        },
        // 存放其它选项中所有选中项的值 
        otherSelectedValArr: [],
        // 筛选view 下边界距离 
        conditionViewLowerBoundary: 0,

        // 排序选项文本
        sortTextArr: [{ check: false, text: '租金从低到高', value: 0 }, { check: false, text: '租金从高到低', value: 1 }, { check: false, text: '最近发布', value: 2 }],
        // 排序选项文本的值
        sortSelectedVal: -1,
        sortSelectedText: '',
        // 筛选view 下边界距离 
        sortViewLowerBoundary: 0,

        // 分页参数 搜索时用
        current: 1,
        pages: 1,
        size: 10,
        // 查询结果数组
        houseArr: [],
    },

    // 预查询 函数
    /**
     * 点击 更多时，更多隐藏，展示多的最近搜索词
     * @param {更多 文本} e 
     */
    showMoreHistorySerarchKey(e) {
        // collapse
        this.setData({ showMoreHistoryFlag: !this.data.showMoreHistoryFlag });
    },


    /**
     * 删除历史搜索记录
     * @param {点击垃圾箱} e 
     */
    delHistorySearchKeys(e) {
        wx.showModal({
            cancelColor: 'rgba(255, 127, 80)',
            // cancelColor: '#5796ff',
            confirmColor: '#A6A6A6',
            title: '',
            content: '确认删除最近搜索记录吗？',
            complete: (res) => {
                if (res.cancel) {
                    console.info('取消')
                }
                if (res.confirm) {
                    console.info('删除')
                    wx.request({
                        url: 'http://' + ip + '/house-rent/delHistorySearchKeys',
                        method: 'POST',
                        header: {
                            'Authorization': token,
                            'content-type': 'application/json;charset=UTF-8'
                        },
                        data: {},
                        success: res => {
                            console.info('删除历史搜索记录=' + JSON.stringify(res))
                            if (res.statusCode == 200) {
                                this.setData({
                                    showHistorySerachKeyFlag: false,
                                    showMoreHistoryFlag: false, searchKeyHistoryArr: [], omitSearchKeyHistoryArr: []
                                });
                            }
                        },
                        fail: e => {
                            console.info('删除历史搜索记录异常返回信息=' + JSON.stringify(e))
                        },
                        complete: c => {
                        }
                    })
                }
            }
        })
    },

    /**
     * 根据输入关键字，批量查询社区名
     * @param {社区名} e 
     */
    getBatchComplex(e) {
        this.pickerChange(e)
        // wx.setStorageSync('searchKeyStr', e.detail.value)
        if (e.detail.value.length == 0) {
            // 获取焦点，如果文本框值为''，则不调后端方法，仍然默认显示
            this.setData({
                showMatchComplexFlag: false,
                showHistorySerachKeyFlag: true,
                showHotSerachKeyFlag: true,
            })
        } else {
            // 根据输入的内容去后端匹配社区名或地址
            this.doGetBatchComplex(e.detail.value);
        }
    },

    doGetBatchComplex(searchKeyStr) {
        // 这个查询不需要分页参数，由后端根据匹配优先级排序，返回匹配度最高的前10条数据
        wx.request({
            url: 'http://' + ip + '/house-rent/getBatchComplex?searchKeyStr=' + searchKeyStr,
            method: 'POST',
            header: {
                'content-type': 'application/json;charset=UTF-8'
            },
            data: {},
            success: res => {
                console.info('关键字匹配社区名返回信息=' + JSON.stringify(res.data.data))
                if (res.statusCode == 200) {
                    const searchKeyMatchArr = res.data.data
                    this.setData({
                        searchKeyMatchArr: searchKeyMatchArr,
                        // 如果返回有数据，则展示匹配view
                        showMatchComplexFlag: searchKeyMatchArr.length > 0,
                        showPageFlag: false,
                        showHistorySerachKeyFlag: false,
                        showHotSerachKeyFlag: false,
                    })
                }
            },
            fail: e => {
                console.info('关键字匹配社区名异常返回信息=' + JSON.stringify(e))
            },
            complete: c => {
                // 防止为了 用户端清空条件过快，而后端返回慢，所以不匹配
                var searchKeyStr = this.data.searchKeyStr
                if (searchKeyStr == '') {
                    this.setData({
                        showMatchComplexFlag: false,
                        showHistorySerachKeyFlag: true,
                        showHotSerachKeyFlag: true,
                    })
                }
                // wx.hideLoading()
            }
        })
    },


    // 1.点击历史搜索 需要把  searchKey 传递过去
    clickHistorySearchKey(e) {
        var historySearchKeyIndex = e.currentTarget.dataset.index;
        // 这里通过索引赋值的是实际词，不是省略词
        const actralSearchKey = this.data.searchKeyHistoryArr[historySearchKeyIndex]
        this.setData({ searchKeyStr: actralSearchKey, showPageFlag: true, current: 1, pages: 1 })
        // 这里不用跳转，而是调用查询方法，并且显示筛选页的view，隐藏pre的view   
        this.doConfirmSearch();
    },
    // 2.点击热搜地点 需要把  searchKey 传递过去
    clickHotSearchKey(e) {
        var hotSearchKeyIndex = e.currentTarget.dataset.index;
        // 这里通过索引赋值的是实际词，不是省略词
        const actralSearchKey = this.data.searchKeyHotArr[hotSearchKeyIndex]
        this.setData({ searchKeyStr: actralSearchKey, showPageFlag: true, current: 1, pages: 1 })
        // 这里不用跳转，而是调用查询方法，并且显示筛选页的view，隐藏pre的view   
        this.doConfirmSearch();
    },
    // 3.点击筛选 需要把 输入的 searchKey 传递过去
    clickSelectBtn(e) {
        this.setData({ showPageFlag: true, current: 1, pages: 1 })
        // 这里不用跳转，而是调用查询方法，并且显示筛选页的view，隐藏pre的view   
        this.doConfirmSearch();
    },
    // 4.点击键盘搜索 需要把 输入的 searchKey 传递过去 // 同3
    // 5.点击匹配的社区名 需要把 选中的 searchKey 传递过去  
    clickComplexBtn(e) {
        // 这里通过索引赋值的是实际词，不是省略词
        const complexName = e.currentTarget.dataset.complex
        this.setData({ searchKeyStr: complexName, showPageFlag: true, current: 1, pages: 1 })
        // 这里不用跳转，而是调用查询方法，并且显示筛选页的view，隐藏pre的view   
        this.doConfirmSearch();
    },
    // 以上需要先给searchKey 赋值，所以如果异步先跳转的话，可以放缓存，在select的页从缓存拿
    // 并且传值参数名不再区分社区或者其它类型，后端查询时将全字匹配的结果放前面，分词匹配的放后面 


    pickerChange: function (e) {
        this.doSetData(e.currentTarget.dataset.atr, e.detail.value)
    },

    doSetData: function (vari, val) { this.setData({ [vari]: val }) },


    getSearchKeyArr: function () {
        // 带上auth参数,查询关键字集合
        wx.request({
            url: 'http://' + ip + '/house-rent/getSearchKeyArr',
            method: 'POST',
            header: {
                'Authorization': token,
                'content-type': 'application/json;charset=UTF-8'
            },
            data: {},
            success: res => {
                console.info('根据openid查询之前的搜索关键字集合返回信息=' + JSON.stringify(res.data))
                if (res.statusCode == 200) {
                    var searchKeyParam = JSON.stringify(res.data.data)
                    const searchKeyParamArr = JSON.parse(searchKeyParam);
                    this.setData({
                        searchKeyHistoryArr: searchKeyParamArr[0],
                        omitSearchKeyHistoryArr: searchKeyParamArr[1],
                        // 大于7，显示'更多'
                        showMoreHistoryFlag: searchKeyParamArr[0].length > 7,
                        showHistorySerachKeyFlag: searchKeyParamArr[0].length > 0,
                        // 热点key
                        searchKeyHotArr: searchKeyParamArr[2],
                        omitSearchKeyHotArr: searchKeyParamArr[3],
                        showHotSerachKeyFlag: searchKeyParamArr[2].length > 0,
                    })
                }
            },
            fail: e => {
                console.info('根据openid查询之前的搜索关键字集合异常返回信息=' + JSON.stringify(e))
            },
            complete: c => {
                // wx.hideLoading()
            }
        })
    },

    // 预查询 函数


    // 筛选页 函数

    // 区域view 方法
    /**
        * 点击任一选项时，遍历每一个选项，若是当前选项，则重置相反的选中状态
        * @param {区域view的展示项} e 
        */
    clickDistrictOption: function (e) {
        const type = e.currentTarget.dataset.type
        const check = e.currentTarget.dataset.check
        const value = e.currentTarget.dataset.value
        var tempDistrictData = this.data.districtData;
        var tempOptionArr = tempDistrictData.optionArr;

        // 遍历每一个选项，若是当前选项，则重置相反的选中状态
        tempOptionArr.forEach(option => {
            if (option.value == value) {
                option.check = !check;
            }
        })

        this.setData({ districtData: tempDistrictData })
    },

    /**
     * 点击确定按钮，遍历收集每个选中项
     * 并且隐藏view
     * @param {区域view的确定按钮} e 
     */
    confirmDistrictOption: function (e) {
        var tempDistrictSelectedValArr = [];
        var tempDistrictData = this.data.districtData;
        var tempOptionArr = tempDistrictData.optionArr;

        var tempDistrictSelectedTextStr = '';
        var tempSelectModuleArr = this.data.selectModuleArr
        // 遍历每一个选项，收集选中项
        tempOptionArr.forEach(option => {
            if (option.check) {
                tempDistrictSelectedValArr.push(option.value);
                // 收集选中项的text组装字符串
                tempDistrictSelectedTextStr += option.text + ','
            }
        })

        tempSelectModuleArr[0].text = tempDistrictSelectedTextStr.length > 0 ? tempDistrictSelectedTextStr.substr(0, tempDistrictSelectedTextStr.length - 1) : this.data.selectModuleTextArr[0]
        this.setData({ districtSelectedValArr: tempDistrictSelectedValArr, selectModuleArr: tempSelectModuleArr, showSelectKindViewFlag: -1, iconSvgSrcArr: iconSvgArr(-1, defaultColor, activeColor), current: 1, pages: 1 })
        console.info('districtSelectedValArr=' + this.data.districtSelectedValArr)
        this.doConfirmSearch();
    },

    /**
     * 点击重置时，遍历每一个选项，设置每一项的选中状态为false
     * 并且清空districtSelectedValArr缓存
     * @param {区域view的取消按钮} e 
     */
    resetDistrictOption: function (e) {
        var tempDistrictData = this.data.districtData;
        var tempOptionArr = tempDistrictData.optionArr;
        // 遍历每一个选项，设置每一项的选中状态为false
        tempOptionArr.forEach(option => {
            option.check = false;
        })

        this.setData({ districtData: tempDistrictData, districtSelectedValArr: [] })
    },

    // 户型view 方法
    /**
       * 点击任一选项时，遍历每一个选项，若是当前选项，则重置相反的选中状态
       * @param {户型view的展示项} e 
       */
    clickLayoutOption: function (e) {
        const type = e.currentTarget.dataset.type
        const check = e.currentTarget.dataset.check
        const value = e.currentTarget.dataset.value
        var tempLayoutData = this.data.layoutData;
        var tempOptionArr = tempLayoutData.optionArr;

        // 遍历每一个选项，若是当前选项，则重置相反的选中状态
        tempOptionArr.forEach(option => {
            if (option.value == value) {
                option.check = !check;
            } else {
                option.check = false;
            }
        })

        this.setData({ layoutData: tempLayoutData })
        this.confirmLayoutOption(e);
    },


    /**
     * 点击确定按钮，遍历收集每个选中项
     * 并且隐藏view
     * @param {户型view的确定按钮} e 
     */
    confirmLayoutOption: function (e) {
        var tempLayoutSelectedVal;
        var tempLayoutData = this.data.layoutData;
        var tempOptionArr = tempLayoutData.optionArr;

        var tempLayoutSelectedTextStr = '';
        var tempSelectModuleArr = this.data.selectModuleArr

        // 遍历每一个选项，收集选中项
        tempOptionArr.forEach(option => {
            if (option.check) {
                tempLayoutSelectedVal = option.value;
                tempLayoutSelectedTextStr = option.text;
                return;
            }
        })

        tempSelectModuleArr[1].text = tempLayoutSelectedTextStr.length > 0 ? tempLayoutSelectedTextStr : this.data.selectModuleTextArr[1]

        this.setData({ layoutSelectedVal: tempLayoutSelectedVal, selectModuleArr: tempSelectModuleArr, showSelectKindViewFlag: -1, iconSvgSrcArr: iconSvgArr(-1, defaultColor, activeColor), current: 1, pages: 1 })
        this.doConfirmSearch();
    },

    /**
     * 点击重置时，遍历每一个选项，设置每一项的选中状态为false
     * 并且清空districtSelectedValArr缓存
     * @param {户型view的取消按钮} e 
     */
    resetLayoutOption: function (e) {
        var tempLayoutData = this.data.layoutData;
        var tempOptionArr = tempLayoutData.optionArr;
        // 遍历每一个选项，设置每一项的选中状态为false
        tempOptionArr.forEach(option => {
            option.check = false;
        })

        this.setData({ layoutData: tempLayoutData, layoutSelectedVal: -1 })
    },

    // 


    // 价格view 方法
    /**
    * 点击任一选项时，遍历每一个选项，若是当前选项，则重置相反的选中状态
    * @param {价格view的展示项} e 
    */
    clickRentOption: function (e) {
        const type = e.currentTarget.dataset.type
        const check = e.currentTarget.dataset.check
        const value = e.currentTarget.dataset.value
        var tempRentData = this.data.rentData;
        var tempOptionArr = tempRentData.optionArr;
        var tempRentSelectedVal;
        // 遍历每一个选项，若是当前选项，则重置相反的选中状态
        tempOptionArr.forEach(option => {
            if (option.value == value) {
                option.check = !check;
                if (!check) {
                    this.calcXByRent(value)
                }
            } else {
                // 其它选项都取消选中，因为是单选
                option.check = false;
            }
        })
        this.setData({ rentData: tempRentData })
    },
    /**
     * 点击确定按钮，单选
     * 隐藏view
     * @param {价格view的确定按钮} e 
     */
    confirmRentOption: function (e) {
        var tempRentTextStr = '';
        console.info('this.data.rent1=' + this.data.rent1)
        console.info('this.data.rent2=' + this.data.rent2)
        if (this.data.rent2 >= initMaxRent) {
            tempRentTextStr = '>' + this.data.rent1;
        } else if (this.data.rent2 > initMinRent) {
            if (this.data.rent2 >= this.data.rent1) {
                tempRentTextStr = this.data.rent1 + '~' + this.data.rent2;
            } else {
                tempRentTextStr = this.data.rent2 + '~' + this.data.rent1;
            }
        } else if (this.data.rent1 == 0 && this.data.rent2 == initMinRent) {
            tempRentTextStr = '<' + this.data.rent2
        }

        var tempSelectModuleArr = this.data.selectModuleArr
        tempSelectModuleArr[2].text = tempRentTextStr.length > 0 ? tempRentTextStr : this.data.selectModuleTextArr[2];

        // 12.6 这里需要给 _x1和_x2赋值，不然再次打开都是0
        this.setData({ rentVal1: this.data.rent1, rentVal2: this.data.rent2, _x1: this.data.x1, _x2: this.data.x2, selectModuleArr: tempSelectModuleArr, showSelectKindViewFlag: -1, iconSvgSrcArr: iconSvgArr(-1, defaultColor, activeColor), current: 1, pages: 1 })
        this.doConfirmSearch();
    },

    /**
     * 点击重置时，遍历每一个选项，设置每一项的选中状态为false
     * 并且清空districtSelectedValArr缓存
     * @param {价格view的取消按钮} e 
     */
    resetRentOption: function (e) {
        var tempRentData = this.data.rentData;
        var tempOptionArr = tempRentData.optionArr;
        // 遍历每一个选项，设置每一项的选中状态为false
        tempOptionArr.forEach(option => {
            option.check = false;
        })

        this.setData({ rentData: tempRentData, x1: 0, x2: 0, _x1: 0, _x2: 0, rent1: initMinRent, rent2: initMinRent, rentVal1: 0, rentVal2: 0 })
    },

    // 价格滑动事件
    onChange: function (e) {
        // console.info('e=' + JSON.stringify(e))
        // console.info('source=' + e.detail.source)
        var name = e.currentTarget.dataset.name;
        this.calcRent(name, e.detail.x, e.detail.source)
    },

    /**
     * 选中租金区间标签，滑动块自动移动到某个位置
     * @param {租金区间标签} rentSelectedVal 
     */
    calcXByRent(rentSelectedVal) {
        const rentSelectedOption = this.data.rentData.optionArr[rentSelectedVal - 1];
        const rentSelectedRange = rentSelectedOption.text;
        var lessThanSignIndex = rentSelectedRange.indexOf('<')
        var greaterThanSignIndex = rentSelectedRange.indexOf('>')
        var rangeSignIndex = rentSelectedRange.indexOf('~')
        var minRentVal = 0;
        var maxRentVal = 0;
        if (lessThanSignIndex !== -1) {
            minRentVal = initMinRent - initMinRent;
            maxRentVal = rentSelectedRange.substr(lessThanSignIndex + 1) - initMinRent;
        } else if (greaterThanSignIndex !== -1) {
            maxRentVal = this.data.maxRent;
            minRentVal = rentSelectedRange.substr(greaterThanSignIndex + 1) - initMinRent;
        } else if (rangeSignIndex !== -1) {
            minRentVal = rentSelectedRange.substr(0, rangeSignIndex) - initMinRent;
            maxRentVal = rentSelectedRange.substr(rangeSignIndex + 1) - initMinRent;
        }
        console.info('minRentVal=' + minRentVal)
        console.info('maxRentVal=' + maxRentVal)

        var tempX1 = 0;
        var tempX2 = 0;
        const ratio = (this.data.maxShowViewWidth / (this.data.maxRent - initMinRent)).toFixed(6)
        // console.info('ratio=' + ratio)

        if (minRentVal > 0) {
            tempX1 = minRentVal * ratio
        } else {
            tempX1 = 0
        }
        if (maxRentVal > 0) {
            tempX2 = maxRentVal * ratio
        } else {
            tempX2 = 0
        }
        console.info('tempX1=' + tempX1)
        console.info('tempX2=' + tempX2)

        // 这里不需要给rent1和rent2赋值，因为给_x1和_x2赋值会触发 change事件，在change事件中做了赋值，但赋值不准确
        this.setData({ _x1: tempX1, _x2: tempX2, rent1: (lessThanSignIndex !== -1 ? minRentVal : minRentVal + initMinRent), rent2: (greaterThanSignIndex !== -1 ? maxRentVal : maxRentVal + initMinRent) })
    },

    /**
     * 根据movable移动的x值计算rent值
     * @param {当前movable对应的rent的名称1/2} name 
     * @param {当前movable移动到的x值} tempX 
     */
    calcRent(name, tempX, source) {
        // 组合名称，赋值用
        var tempRentKey = 'rent' + name;
        // 初始宽度movableWidth = 96%vm; 需要减去两个movable各50%的宽度（即30rpx,共60rpx即30px）为实际可移动的宽度/距离
        // const maxMovableWidth = this.data.movableWidth - 30;
        // 当前机型下movable块的宽度，单位px
        // const movableViewWidthPX = (this.data.movableViewWidthRPX * app.globalData.windowWidth / 750).toFixed(6)
        // var maxShowViewWidth = this.data.movableAreaWidth - movableViewWidthPX;
        // const maxMovableWidth = this.data.movableAreaWidth - movableViewWidthPX;
        const tempMaxRent = this.data.maxRent
        const tempMinRent = this.data.minRent
        const maxShowViewWidth = this.data.maxShowViewWidth;
        // console.info('maxShowViewWidth=' + maxShowViewWidth)
        // console.info('tempX=' + tempX)

        this.setData({ ['x' + name]: tempX })
        // console.info(this.data['_x' + name])


        // 以下是对实际租金的赋值
        // 为了避免出现数据和标题显示的数据不对应，在这里加判断

        if (source !== 'touch') {
            // console.info('-------')
            return;
        }
        // console.info("touch")
        // ><增加大于小于判断是为了防止特殊情况越界
        // 如果移动到最末端，则对应的赋值为最大值
        if (tempX >= maxShowViewWidth) {
            this.setData({ [tempRentKey]: tempMaxRent })
        } else if (tempX <= 0) {
            // 如果移动到最左端，则对应的赋值为最小值
            this.setData({ [tempRentKey]: tempMinRent })
        } else {
            // 在最大和最小之间，则按比例换算
            // 最大-最小 才是实际区间，保留小数
            var ratio = (maxShowViewWidth / (tempMaxRent - tempMinRent)).toFixed(6);
            // 这里不需要小数了, 另要+起始值才是要显示的数值  使用Math四舍五入取整数
            var tempRent = Math.round(tempX / ratio) + tempMinRent;
            // 避免小数计算误差，超过最大rent
            this.setData({ [tempRentKey]: tempRent > tempMaxRent ? tempMaxRent : tempRent })
            // console.info('ratio=' + ratio)
            // console.info('tempRent=' + tempRent)
        }
    },



    // 筛选view 方法
    /**
    * 点击任一选项时，遍历每一个选项，若是当前选项，则重置相反的选中状态
    * @param {筛选view的承租方式展示项} e 
    */
    clickRentTypeOption: function (e) {
        const type = e.currentTarget.dataset.type
        const check = e.currentTarget.dataset.check
        const value = e.currentTarget.dataset.value
        var tempRentTypeData = this.data.rentTypeData;
        var tempOptionArr = tempRentTypeData.optionArr;
        var tempRentSelectedVal;
        // 遍历每一个选项，若是当前选项，则重置相反的选中状态
        tempOptionArr.forEach(option => {
            if (option.value == value) {
                option.check = !check;
                if (!check) {
                    //如果当前点击效果是：选中某项，则将此项的value赋值给rentVal
                    tempRentSelectedVal = value;
                }
            } else {
                // 其它选项都取消选中，因为是单选
                option.check = false;
            }
        })

        this.setData({ rentTypeData: tempRentTypeData, rentTypeSelectedVal: tempRentSelectedVal })
    },

    /**
     * 点击任一选项时，遍历每一个选项，若是当前选项，则重置相反的选中状态  多选
     * @param {筛选view的展示项} e 
     */
    clickOtherOption: function (e) {
        const type = e.currentTarget.dataset.type
        const check = e.currentTarget.dataset.check
        const value = e.currentTarget.dataset.value
        var tempOtherConditionData = this.data.otherConditionData;
        var tempOptionArr = tempOtherConditionData.optionArr;
        var tempOtherSelectedValArr = [];
        // 遍历每一个选项，若是当前选项，则重置相反的选中状态
        tempOptionArr.forEach(option => {
            if (option.value == value) {
                option.check = !check;
            }
            if (!check) {
                // 收集选中项数据
                tempOtherSelectedValArr.push(option.value);
            }
        })

        // 快速查找 模块处理
        var tempFastSearchArr = this.data.fastSearchArr
        tempFastSearchArr.forEach(option => {
            if (option.value == value) {
                option.check = !check;
            }
        })
        // 快速查找 模块处理

        this.setData({ fastSearchArr: tempFastSearchArr, otherConditionData: tempOtherConditionData, otherSelectedValArr: tempOtherSelectedValArr })
    },

    /**
     * 点击重置时，遍历每一个选项，设置每一项的选中状态为false
     * 并且清空districtSelectedValArr缓存
     * @param {其它选项的view的取消按钮} e 
     */
    resetOtherConditionOption: function (e) {
        // 承租方式 清空
        var tempRentTypeData = this.data.rentTypeData;
        var tempRentTypeOptionArr = tempRentTypeData.optionArr;
        // 遍历每一个选项，设置每一项的选中状态为false
        tempRentTypeOptionArr.forEach(option => {
            option.check = false;
        })

        var tempOtherConditionData = this.data.otherConditionData;
        var tempOtherOptionArr = tempOtherConditionData.optionArr;
        // 遍历每一个选项，设置每一项的选中状态为false
        tempOtherOptionArr.forEach(option => {
            option.check = false;
        })

        this.setData({ rentTypeData: tempRentTypeData, rentTypeSelectedVal: '', otherConditionData: tempOtherConditionData, otherSelectedValArr: [] })
    },

    confirmOtherConditionOption(e) {
        var tempOtherSelectedTextStr = '';
        var tempSelectModuleArr = this.data.selectModuleArr


        var tempRentTypeData = this.data.rentTypeData;
        var tempRentTypeOptionArr = tempRentTypeData.optionArr;
        var tempRentTypeSelectedVal = -1;

        // 遍历每一个选项
        tempRentTypeOptionArr.forEach(option => {
            if (option.check) {
                tempRentTypeSelectedVal = option.value;
                tempOtherSelectedTextStr += option.text + ',';
                return;
            }
        })

        var tempOtherSelectedValArr = []
        var tempOtherConditionData = this.data.otherConditionData;
        var tempOtherOptionArr = tempOtherConditionData.optionArr;
        // 遍历每一个选项，设置每一项的选中状态为false
        tempOtherOptionArr.forEach(option => {
            if (option.check) {
                tempOtherSelectedValArr.push(option.value)
                tempOtherSelectedTextStr += option.text + ',';
            }
        })

        console.info(tempOtherSelectedTextStr)
        tempSelectModuleArr[3].text = tempOtherSelectedTextStr.length > 0 ? tempOtherSelectedTextStr.substr(0, tempOtherSelectedTextStr.length - 1) : this.data.selectModuleTextArr[3]

        this.setData({ rentTypeSelectedVal: tempRentTypeSelectedVal, otherSelectedValArr: tempOtherSelectedValArr, selectModuleArr: tempSelectModuleArr, showSelectKindViewFlag: -1, iconSvgSrcArr: iconSvgArr(-1, defaultColor, activeColor), current: 1, pages: 1 })
        this.doConfirmSearch();
    },

    /**
     * 点击快速查询选项
     * 选中的同时，同步选中状态给筛选view，并且查询
     * @param {快速查询选项} e 
     */
    clickFastSearch(e) {
        const otherSelectedValParam = e.currentTarget.dataset.value
        if (otherSelectedValParam != undefined) {
            if (otherSelectedValParam == -1) {
                // 即全部，调用reset方法，
                // 所有清空
                this.resetDistrictOption()
                this.resetLayoutOption()
                this.resetRentOption()
                this.resetOtherConditionOption()
                // 快速查询的清空
                var tempFastSearchArr = this.data.fastSearchArr
                tempFastSearchArr.forEach(option => {
                    option.check = false;
                })

                // 把标题重新赋值
                var tempSelectModuleArr = this.data.selectModuleArr
                for (let index = 0; index < tempSelectModuleArr.length; index++) {
                    var element = tempSelectModuleArr[index];
                    element.text = this.data.selectModuleTextArr[index]
                }

                this.setData({ fastSearchArr: tempFastSearchArr, selectModuleArr: tempSelectModuleArr, current: 1, pages: 1 })
                this.doConfirmSearch();
                return;
            }
            console.info('----------------------------------')
            // 模拟确定按钮
            // 这是承租类型的获取值 
            var tempRentTypeData = this.data.rentTypeData;
            var tempRentTypeOptionArr = tempRentTypeData.optionArr;
            var tempRentTypeSelectedVal = -1;
            var tempOtherSelectedTextStr = '';
            // 遍历每一个选项
            tempRentTypeOptionArr.forEach(option => {
                if (option.check) {
                    tempRentTypeSelectedVal = option.value;
                    tempOtherSelectedTextStr += option.text + ',';
                    return;
                }
            })

            // 这是弹窗view 的点
            var tempOtherSelectedValArr = []
            var tempOtherConditionData = this.data.otherConditionData;
            var tempOtherOptionArr = tempOtherConditionData.optionArr;
            // 遍历每一个选项
            tempOtherOptionArr.forEach(option => {
                // 这里是把点击选中 和确定 合并在一起了，因为触发方是 快速查询，点击选中就相当于确定了
                if (option.value == otherSelectedValParam) {
                    option.check = !option.check;
                }
                if (option.check) {
                    tempOtherSelectedValArr.push(option.value)
                    tempOtherSelectedTextStr += option.text + ',';
                }
            })

            var tempSelectModuleArr = this.data.selectModuleArr
            tempSelectModuleArr[3].text = tempOtherSelectedTextStr.length > 0 ? tempOtherSelectedTextStr.substr(0, tempOtherSelectedTextStr.length - 1) : this.data.selectModuleTextArr[3]

            // 这里是快速查找的点击处理
            var tempFastSearchArr = this.data.fastSearchArr
            tempFastSearchArr.forEach(option => {
                if (option.value == otherSelectedValParam) {
                    option.check = !option.check;
                }
            })


            // 赋值并查询
            this.setData({ otherConditionData: tempOtherConditionData, rentTypeSelectedVal: tempRentTypeSelectedVal, otherSelectedValArr: tempOtherSelectedValArr, selectModuleArr: tempSelectModuleArr, fastSearchArr: tempFastSearchArr, showSelectKindViewFlag: -1, iconSvgSrcArr: iconSvgArr(-1, defaultColor, activeColor), current: 1, pages: 1 })
            this.doConfirmSearch();
        }
    },


    // 排序 方法 
    clickSortOption(e) {
        const check = e.currentTarget.dataset.check
        var tempSelectModuleArr = this.data.selectModuleArr

        // sortVal 赋值
        var selectedSortItem = e.currentTarget.dataset.item;
        var tempSortSelectedVal = this.data.sortSelectedVal;

        if (!check) {
            var tempSortSelectedTextStr = selectedSortItem.text
            tempSelectModuleArr[4].text = tempSortSelectedTextStr.length > 0 ? tempSortSelectedTextStr : this.data.selectModuleTextArr[4]
            tempSortSelectedVal = selectedSortItem.value
        } else {
            tempSelectModuleArr[4].text = this.data.selectModuleTextArr[4]
            tempSortSelectedVal = -1
        }

        var tempOptionArr = this.data.sortTextArr;
        // 遍历每一个选项，若是当前选项，则重置相反的选中状态
        tempOptionArr.forEach(option => {
            if (option.value == selectedSortItem.value) {
                option.check = !check;
            } else {
                option.check = false;
            }
        })

        this.setData({ sortTextArr: tempOptionArr, sortSelectedVal: tempSortSelectedVal, selectModuleArr: tempSelectModuleArr, showSelectKindViewFlag: -1, iconSvgSrcArr: iconSvgArr(-1, defaultColor, activeColor), current: 1, pages: 1 })
        // 变颜色
        // 显示文字
        // 关闭弹出层
        // 调用查询方法
        this.doConfirmSearch();
    },


    /**
     * 点击区域，显示区域选项，多选
     * @param {区域} e 
     */
    showSelectKindView: function (e) {
        const item = e.currentTarget.dataset.item;
        var kind = e.currentTarget.dataset.index;
        var currentShowFlag = this.data.showSelectKindViewFlag
        if (currentShowFlag == kind) {
            // 同一菜单多次点击
            kind = -1;
        } else {
            // 判断是否有值 ，无值再调用函数
            var tempViewLowerBoundary = this.data[item.viewId + 'ViewLowerBoundary'];
            if (tempViewLowerBoundary == 0) {
                this.getViewLowerBoundary(item.viewId)
            }
        }

        this.setData({ showSelectKindViewFlag: kind, iconSvgSrcArr: iconSvgArr(kind, defaultColor, activeColor) })
    },

    /**
     * 点击每个标题项，显示弹出层，计算每个弹出层的下边界是为了，点击层外来hide弹出层，并不是为了定位
     * @param {标题项} viewId 
     */
    getViewLowerBoundary(viewId) {
        setTimeout(() => {
            let query = wx.createSelectorQuery();
            query.select('#' + viewId).boundingClientRect(rect => {
                console.log(rect);
                let height = rect.height;
                // top:129
                console.log(height);
                this.setData({ [viewId + 'ViewLowerBoundary']: rect.height + rect.top })
            }).exec();
        }, 300)
    },

    /**
   * 隐藏view
   * @param {窗口的蒙版层} e 
   */
    hideSelectView: function (e) {
        // const name = e.currentTarget.dataset.name;
        // var kindFlag = name === 'area';
        // var dh = kindFlag ? 365 : 423;
        var tempShowSelectKindViewFlag = this.data.showSelectKindViewFlag
        if (tempShowSelectKindViewFlag >= 0) {
            const viewId = this.data.selectModuleArr[tempShowSelectKindViewFlag].viewId
            console.info(viewId + 'ViewLowerBoundary:  ' + this.data[viewId + 'ViewLowerBoundary']);
            console.info('e.touches[0].clientY:  ' + e.touches[0].clientY);
            if (e.touches[0].clientY > (this.data[viewId + 'ViewLowerBoundary'])) {
                this.setData({ showSelectKindViewFlag: -1, iconSvgSrcArr: iconSvgArr(-1, defaultColor, activeColor) });
                // 12.6 这里要判断下，在租金弹窗，如果手动滑动滑块，然后直接点击蒙版或moduleTitle，需要给_x1和_x2赋值为x1和x2
                if (tempShowSelectKindViewFlag == 2) {
                    // 租金view 
                    this.setData({ _x1: this.data.x1, _x2: this.data.x2 })
                }
            }
        }
    },

    /**
     * 实际最终的查询方法
     */
    doConfirmSearch() {
        // 这里要在 show函数中判断是否重置参数，若是没有变化，则不需要，若是筛选页点的是确定，但没有条件（则实质结果是一样的，就不需要重置）
        var tempArr = this.data.houseArr;
        var tempCurrent = this.data.current;

        if (tempCurrent > this.data.pages) {
            console.info('tempCurrent=' + tempCurrent + " 已超过总页数=" + this.data.pages);
            return;
        }

        var tempRentVal1 = this.data.rentVal1
        var tempRentVal2 = this.data.rentVal2
        if (this.data.rentVal1 > this.data.rentVal2) {
            tempRentVal1 = this.data.rentVal2
            tempRentVal2 = this.data.rentVal1
        }
        var searchDTOParam = { districtArr: this.data.districtSelectedValArr, rooms: this.data.layoutSelectedVal, minRent: tempRentVal1, maxRent: tempRentVal2, rentType: this.data.rentTypeSelectedVal, strongPoint: this.data.otherSelectedValArr };

        // console.info('searchDTOCache=' + JSON.stringify(searchDTOCache))

        wx.request({
            url: 'http://' + ip + '/house-rent/getHouseByAllCondition?searchKeyStr=' + this.data.searchKeyStr + "&complex=" + this.data.complex + '&current=' + tempCurrent + '&orderBy=' + this.data.sortSelectedVal,
            method: 'POST',
            header: {
                'Authorization': token,
                'content-type': 'application/json;charset=UTF-8'
            },
            data: searchDTOParam,
            success: res => {
                console.info('根据所有条件查询返回信息=' + JSON.stringify(res.data.data))
                if (res.statusCode == 200) {
                    if (tempCurrent > 1) {
                        const records = tempArr.concat(res.data.data.records);
                        this.setData({ houseArr: records })
                    } else {
                        this.setData({ houseArr: res.data.data.records, pages: res.data.data.pages })
                    }
                    this.setData({
                        current: tempCurrent + 1,
                        showMatchComplexFlag: false,
                        // searchHouseArr: records,
                    })
                    // if (tempCurrent == 1) {
                    //     this.setData({ allPages: res.data.data.pages })
                    // }
                }
            },
            fail: e => {
                console.info('根据所有条件查询返回信息=' + JSON.stringify(e))
            },
            complete: c => {
                wx.hideLoading()
            }
        })
    },

    /**
     * 点击 房屋信息 跳转到详情页
     * @param {房屋} e 
     */
    toHouseInfo: function (e) {
        var url = '/pages/nuan/info/houseInfo?houseId=' + e.currentTarget.dataset.id;
        common.navigateTo2(url)
    },

    /**
     * 点击链接 跳转到发布需求页
     * @param {文本链接} e 
     */
    toNeedHouse: function (e) {
        var url = '/pages/nuan/need/needHouse';
        common.navigateTo2(url)
    },
    // 蒙版层出现时，禁止上下滚动页面
    preventTouchMove: function (e) {
        return
    },
    // 筛选页 函数

    /**
     * 生命周期函数--监听页面加载
     */
    onLoad(options) {
        // 因为从不同页面会需要显示 预查询或筛选，所以这里要根据参数区分
        // fromType:0 预查询 :1 筛选
        const fromType = options.fromType;
        if (fromType == undefined) {
            return;
        }

        this.setData({ showPageFlag: fromType == 1 });

        // 当前机型下movable块的宽度，单位px
        const movableViewWidthPX = (this.data.movableViewWidthRPX * app.globalData.windowWidth / 750).toFixed(6)
        this.setData({ maxShowViewWidth: this.data.movableAreaWidth - movableViewWidthPX })

        // 计算rent范围初始值
        // 最大-最小 才是实际区间，保留小数
        this.calcRent(1, this.data._x1);
        this.calcRent(2, this.data._x2);

        // 筛选函数 
        if (fromType == 1) {
            // 从首页过来可能会传rentType:0/1 短租：otherSelectedVal=7
            // 相当于触发click方法
            var tempSelectModuleArr = this.data.selectModuleArr
            // rentType处理
            const rentTypeParam = options.rentType
            // var tempOtherSelectedTextStr = '';
            if (rentTypeParam != undefined) {
                var tempRentTypeData = this.data.rentTypeData;
                var tempOptionArr = tempRentTypeData.optionArr;
                // 遍历每一个选项，若是当前选项，则重置相反的选中状态
                tempOptionArr.forEach(option => {
                    option.check = option.value == rentTypeParam
                    if (option.value == rentTypeParam) {
                        tempSelectModuleArr[3].text = option.text
                        return;
                    }
                })
                // tempSelectModuleArr[3].text = tempOtherSelectedTextStr.length > 0 ? tempOtherSelectedTextStr : this.data.selectModuleTextArr[3]
                this.setData({ rentTypeData: tempRentTypeData, rentTypeSelectedVal: rentTypeParam, selectModuleArr: tempSelectModuleArr })
            } else {
                // 短租：otherSelectedVal=7处理
                // var tempOtherSelectedTextStr = '';
                const otherSelectedValParam = options.otherSelectedVal
                if (otherSelectedValParam != undefined) {
                    var tempOtherConditionData = this.data.otherConditionData;
                    var tempOptionArr = tempOtherConditionData.optionArr;
                    var tempOtherSelectedValArr = [];
                    tempOtherSelectedValArr.push(otherSelectedValParam)
                    // 遍历每一个选项，若是当前选项，则重置相反的选中状态
                    tempOptionArr.forEach(option => {
                        option.check = option.value == otherSelectedValParam
                        if (option.value == otherSelectedValParam) {
                            tempSelectModuleArr[3].text = option.text
                            return;
                        }
                    })
                    this.setData({ otherConditionData: tempOtherConditionData, otherSelectedValArr: tempOtherSelectedValArr, selectModuleArr: tempSelectModuleArr })
                }
            }

            // this.setData({ selectModuleArr: tempSelectModuleArr, iconSvgSrcArr: iconSvgArr(-1, defaultColor, activeColor), current: 1, pages: 1 })
            this.doConfirmSearch()
            // 筛选函数 
        } else if (fromType == 0) {
            // 弱化0的类型页面 
        }

        // 预查询 函数 加载时调用后端查询 历史搜索词和热点词接口
        // 无论0/1都执行该函数，因为即使1过来，输入参数也可能会触发
        this.getSearchKeyArr()
        // 并非从其它页面直接到筛选页，而是从预查询的动作，显示筛选层
        //    放在最后面，延迟获取
        setTimeout(() => {
            let query = wx.createSelectorQuery();
            query.select('#selectView').boundingClientRect(rect => {
                console.info(rect)
                this.setData({ topViewLowerBoundary: rect.bottom })
            }).exec();
        }, 2000)

        console.info('topViewLowerBoundary=' + this.data.topViewLowerBoundary)
        console.info('windowHeight=' + this.data.windowHeight)
    },
})